{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "metallic-thriller",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 4.23 s (started: 2021-07-22 11:02:14 +08:00)\n"
     ]
    }
   ],
   "source": [
    "# 自动计算cell的计算时间\n",
    "%load_ext autotime\n",
    "\n",
    "#设置使用的gpu\n",
    "import tensorflow as tf\n",
    "\n",
    "gpus = tf.config.list_physical_devices(\"GPU\")\n",
    "\n",
    "if gpus:\n",
    "   \n",
    "    gpu0 = gpus[2] #如果有多个GPU，仅使用第0个GPU\n",
    "    tf.config.experimental.set_memory_growth(gpu0, True) #设置GPU显存用量按需使用\n",
    "    # 或者也可以设置GPU显存为固定使用量(例如：4G)\n",
    "    #tf.config.experimental.set_virtual_device_configuration(gpu0,\n",
    "    #    [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=4096)]) \n",
    "    tf.config.set_visible_devices([gpu0],\"GPU\") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "biological-publicity",
   "metadata": {},
   "source": [
    "# Keras 和 TensorFlow 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "serious-gardening",
   "metadata": {},
   "source": [
    ">本章包括\n",
    "* 深入了解 TensorFlow、Keras 及其关系\n",
    "* 设置深度学习工作区\n",
    "* 核心深度学习概念如何转化为 Keras 和 TensorFlow 的概述"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cellular-bundle",
   "metadata": {},
   "source": [
    "本章旨在为您提供在实践中开始深度学习所需的一切。 我们将向您简要介绍 Keras ( keras.io) 和 TensorFlow (tensorflow.org)，这是我们将在整本书中使用的基于 Python 的深度学习工具。 您将了解如何使用 TensorFlow、Keras 和 GPU 支持设置深度学习工作区。 最后，在您在第 2 章中第一次接触 Keras 和 TensorFlow 的基础上，我们将回顾神经网络的核心组件以及它们如何转换为 Keras 和 TensorFlow API。 在本章结束时，您将准备好进入实际的、真实的应用程序——这将从第 4 章开始。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "worst-sunrise",
   "metadata": {},
   "source": [
    "## 什么是Tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "about-reunion",
   "metadata": {},
   "source": [
    "TensorFlow 是一个基于 Python 的免费开源机器学习平台，主要由 Google 开发。 与 NumPy 非常相似，TensorFlow 的主要目的是让工程师和研究人员能够在数值张量上操作数学表达式。 但是 TensorFlow 在以下方面远远超出了 NumPy 的范围：\n",
    "* 它可以自动计算任何可微表达式的梯度（如您在第 2 章中看到的），使其非常适合机器学习。\n",
    "* 它不仅可以运行在 CPU 上，还可以运行在 GPU 和 TPU、高度并行的硬件加速器上。\n",
    "* TensorFlow 中定义的计算可以轻松地分布在多台机器上。\n",
    "* TensorFlow 程序可以导出到其他运行时，例如 C++、JavaScript（用于基于浏览器的应用程序）或 TFLite（用于在移动设备或嵌入式设备上运行的应用程序）等。这使得 TensorFlow 应用程序易于在实际设置中部署。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "loving-captain",
   "metadata": {},
   "source": [
    "重要的是要记住，TensorFlow 不仅仅是一个库。 它确实是一个平台，拥有庞大的组件生态系统，其中一些由 Google 开发，一些由第三方开发。 例如，有用于强化学习研究的 TF-Agents，用于行业强度机器学习工作流管理的 TFX，用于生产部署的 TF-Serving，还有预训练模型的 TF-Hub 存储库……这些组件涵盖了非常广泛的领域 用例，从前沿研究到大规模生产应用。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acceptable-silicon",
   "metadata": {},
   "source": [
    "TensorFlow 的扩展性相当好：例如，橡树岭国家实验室的科学家已经使用它在 IBM Summit 超级计算机的 27,000 个 GPU 上训练了 1.1 ExaFLOP 极端天气预报模型。 同样，谷歌使用 TensorFlow 开发了计算密集型深度学习应用程序，例如国际象棋和围棋代理 AlphaZero。 对于您自己的模型，如果您有预算，您实际上可以希望在一个小型 TPU Pod 或在 Google Cloud 或 AWS 上租用的大型 GPU 集群上扩展到大约 10 PetaFLOP。 这仍然是 2019 年顶级超级计算机峰值计算能力的 1% 左右！"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "logical-google",
   "metadata": {},
   "source": [
    "## 什么是Keras?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "northern-liberia",
   "metadata": {},
   "source": [
    "Keras 是 Python 的深度学习 API，构建在 TensorFlow 之上，提供了一种方便的方式来定义和训练任何类型的深度学习模型。 Keras 最初是为研究而开发的，旨在实现快速的深度学习实验。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "stable-gross",
   "metadata": {},
   "source": [
    "通过 TensorFlow，Keras 可以在不同类型的硬件上运行（见图 3.1）——GPU、TPU 或普通 CPU——并且可以无缝扩展到数千台机器。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "diverse-acquisition",
   "metadata": {},
   "source": [
    "![](https://tva1.sinaimg.cn/large/008i3skNgy1gsmq42w5hvj31cg0kktbk.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reflected-species",
   "metadata": {},
   "source": [
    "Keras 以优先考虑开发人员的经验而闻名。 它是面向人类的 API，而不是面向机器的 API。 它遵循减少认知负荷的最佳实践：它提供一致且简单的工作流程，最大限度地减少常见用例所需的操作数量，并针对用户错误提供清晰且可操作的反馈。 这使得 Keras 作为初学者很容易学习，并且作为专家使用时效率很高。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "appointed-geography",
   "metadata": {},
   "source": [
    "截至 2021 年年中，Keras 拥有超过 400,000 名用户，从初创公司和大公司的学术研究人员、工程师和数据科学家，到研究生和业余爱好者。 谷歌、Netflix、优步、欧洲核子研究中心、美国宇航局、Yelp、Instacart、Square 以及数百家初创公司都在使用 Keras，这些初创公司致力于解决各个行业的各种问题。 您的 YouTube 推荐源自 Keras 模型。 Waymo 自动驾驶汽车是使用 Keras 模型开发的。 Keras 也是机器学习竞赛网站 Kaggle 上的一个流行框架，大多数深度学习竞赛都是使用 Keras 赢得的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thirty-tours",
   "metadata": {},
   "source": [
    "由于 Keras 拥有庞大且多样化的用户群，因此它不会强迫您遵循单一的“真实”方式来构建和训练模型。 相反，它支持各种不同的工作流程，从非常高级到非常低级，对应于不同的用户配置文件。 为了\n",
    "例如，您有多种构建模型的方法和多种训练模型的方法，每种方法都代表了可用性和灵活性之间的某种权衡。 在第 5 章中，我们将详细回顾这一系列工作流中的大部分内容。 你可以像使用 Scikit-Learn 一样使用 Keras——只是调用并让框架做它的事情——或者你可以像 NumPy 一样使用 fit()——完全控制每一个小细节。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moving-contract",
   "metadata": {},
   "source": [
    "这意味着，一旦您成为专家，您现在开始学习的所有内容仍然具有相关性。 您可以轻松入门，然后逐渐深入到从头开始编写越来越多逻辑的工作流程。 从学生到研究人员，或从数据科学家到深度学习工程师，您无需切换到完全不同的框架。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "inappropriate-encyclopedia",
   "metadata": {},
   "source": [
    "这种哲学与 Python 本身没有什么不同！ 某些语言仅提供一种编写程序的方法——例如，面向对象编程或函数式编程。 同时，Python 是一种多范式语言：它提供了一系列可能的使用模式，它们可以很好地协同工作。 这使得 Python 适用于各种非常不同的用例：系统管理、数据科学、机器学习工程、Web 开发……或者只是学习如何编程。 同样，您可以将 Keras 视为深度学习的 Python：一种用户友好的深度学习语言，可为不同的用户配置文件提供各种工作流程。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "turned-operator",
   "metadata": {},
   "source": [
    "## Keras 和 TensorFlow：简史"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tropical-wheat",
   "metadata": {},
   "source": [
    "Keras 比 TensorFlow 早八个月。 它是2015年3月发布的，而TensorFlow是2015年11月发布的。你可能会问，如果Keras是建立在TensorFlow之上的，那么在TensorFlow发布之前它怎么可能存在？ Keras 最初构建在 Theano 之上，后者是另一个提供自动微分和 GPU 支持的张量操作库——同类中最早的。 Theano 由蒙特利尔大学的蒙特利尔学习算法研究所 (MILA) 开发，在很多方面都是 TensorFlow 的前身。 它开创了使用静态计算图进行自动微分以及将代码编译到 CPU 和 GPU 的想法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "theoretical-simpson",
   "metadata": {},
   "source": [
    "2015 年底，TensorFlow 发布后，Keras 被重构为多后端架构：Keras 与 Theano 或 TensorFlow 一起使用成为可能，两者之间的切换就像更改环境变量一样简单。 到 2016 年 9 月，TensorFlow 已达到技术成熟的水平，可以使其成为 Keras 的默认后端选项。 2017 年，Keras 增加了两个新的后端选项：CNTK（由微软开发）和 MXNet（由亚马逊开发）。 如今，Theano 和 CNTK 都处于不再开发阶段，MXNet 在亚马逊之外也没有广泛使用。 Keras 又回到了单一后端 API——在 TensorFlow 之上。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "through-description",
   "metadata": {},
   "source": [
    "Keras 和 TensorFlow 多年来一直保持着共生关系。 在整个 2016 年和 2017 年，Keras 以用户友好的方式开发 TensorFlow 应用程序而闻名，它将新用户引入 TensorFlow 生态系统。 到 2017 年底，大多数 TensorFlow 用户通过 Keras 或与 Keras 结合使用它。 2018 年，TensorFlow 领导层选择 Keras 作为 TensorFlow 的官方高级 API。 因此，Keras API 在 2019 年 9 月发布的 TensorFlow 2.0 中处于前沿和中心位置——对 TensorFlow 和 Keras 进行了广泛的重新设计，其中考虑了四年多的用户反馈和技术进步。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lightweight-laser",
   "metadata": {},
   "source": [
    "至此，您一定渴望开始在实践中运行 Keras 和 TensorFlow 代码。 让我们开始吧。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sized-growth",
   "metadata": {},
   "source": [
    "## 设置深度学习工作区"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "amended-dialogue",
   "metadata": {},
   "source": [
    "在开始开发深度学习应用程序之前，您需要设置开发环境。 强烈建议您在现代 NVIDIA GPU 而不是计算机的 CPU 上运行深度学习代码，尽管不是绝对必要的。 某些应用程序——尤其是使用卷积网络的图像处理——在 CPU 上会极其缓慢，即使是快速的多核 CPU。 即使对于实际上可以在 CPU 上运行的应用程序，通过使用最新的 GPU，您通常也会看到速度提高 1 倍或 5 倍或 10 倍。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "elect-cache",
   "metadata": {},
   "source": [
    "要在 GPU 上进行深度学习，您有以下三种选择：\n",
    "* 购买并在您的工作站上安装物理 NVIDIA GPU。\n",
    "* 在 Google Cloud Platform 或 AWS EC2 上使用 GPU 实例。\n",
    "* 使用 Colaboratory 提供的免费 GPU 运行时，这是 Google 提供的托管笔记本服务（有关什么是“笔记本”的详细信息，请参阅下一节）。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "vietnamese-peace",
   "metadata": {},
   "source": [
    "Colaboratory 是最简单的入门方式，因为它不需要购买硬件，也不需要安装软件——只需在浏览器中打开一个选项卡并开始编码。 这是我们推荐用于运行本书中的代码示例的选项。 但是，Colaboratory 的免费版本仅适用于小型工作负载。 如果您想扩大规模，则必须使用第一个或第二个选项。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acquired-chain",
   "metadata": {},
   "source": [
    "如果您还没有可用于深度学习的 GPU（最近推出的高端 NVIDIA GPU），那么在云中运行深度学习实验是一种简单、低成本的方式，可让您迁移到更大的平台 工作负载，而无需购买任何额外的硬件。 如果您使用 Jupyter notebook 进行开发，那么在云端运行的体验与在本地运行没有什么不同。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unlike-christmas",
   "metadata": {},
   "source": [
    "但是，如果您是深度学习的重度用户，那么这种设置从长远来看是不可持续的——甚至超过几个月。 云实例并不便宜：到 2019 年底，您需要为 Google Cloud 上的 P100 GPU 支付每小时 1.46 美元。与此同时，坚固的消费级 GPU 将花费您大约 1,500 到 2,500 美元——这个价格已经相当 随着时间的推移稳定，即使这些 GPU 的规格不断改进。 如果您是深度学习的重度用户，请考虑使用一个或多个 GPU 设置本地工作站。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "supposed-satin",
   "metadata": {},
   "source": [
    "此外，无论您是在本地运行还是在云端运行，最好使用 Unix 工作站。 尽管技术上可以直接在 Windows 上运行 Keras，但我们不建议这样做。 如果您是 Windows 用户并且想自己进行深度学习\n",
    "工作站，让一切运行的最简单解决方案是在您的机器上设置 Ubuntu 双引导，或者利用适用于 Linux 的 Windows 子系统 (WSL)，这是一个兼容层，使您能够从 Windows 运行 Linux 应用程序。 这可能看起来很麻烦，但从长远来看，它会为您节省大量时间和麻烦。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "standing-center",
   "metadata": {},
   "source": [
    "### Jupyter notebooks：运行深度学习实验的首选方式"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "subjective-paint",
   "metadata": {},
   "source": [
    "Jupyter notebook 是运行深度学习实验的好方法——尤其是本书中的许多代码示例。 它们被广泛用于数据科学和机器学习社区。 A 是由 Jupyter Notebook 应用程序 ( jupyter.org ) 生成的文件，您可以在浏览器中编辑该 notebook。 它混合了执行 Python 代码的能力和丰富的文本编辑能力，用于注释你正在做的事情。 笔记本还允许您将长时间的实验分解成可以独立执行的较小部分，这使得开发具有交互性，并且意味着如果实验后期出现问题，您不必重新运行所有以前的代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "distributed-burden",
   "metadata": {},
   "source": [
    "我们建议使用 Jupyter notebooks 开始使用 Keras，尽管这不是必需的：您还可以运行独立的 Python 脚本或从 IDE（例如 PyCharm）中运行代码。 本书中的所有代码示例都可以作为开源笔记本使用； 你可以在 github.com/fchollet/deep-learning-with-python-notebooks 从 Githum 下载它们。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "respective-worker",
   "metadata": {},
   "source": [
    "### 使用Colaboratory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "changing-mention",
   "metadata": {},
   "source": [
    "Colaboratory（或简称 Colab）是一种免费的 Jupyter notebook 服务，无需安装，完全在云端运行。 实际上，它是一个网页，可让您立即编写和执行 Keras 脚本。 它让您可以访问免费（但有限）的 GPU 运行时甚至 TPU 运行时，因此您无需购买自己的 GPU。 我们推荐使用 Colaboratory 来运行本书中的代码示例。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "according-audience",
   "metadata": {},
   "source": [
    "**COLABORATORY的第一步**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hispanic-piece",
   "metadata": {},
   "source": [
    "要开始使用 Colab，请转到 colab.research.google.com 并单击“新建笔记本”按钮。 您将进入标准 Notebook 界面："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "coordinated-junction",
   "metadata": {},
   "source": [
    "![](https://tva1.sinaimg.cn/large/008i3skNgy1gsmrbwot3dj31am0k4q4i.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seven-forward",
   "metadata": {},
   "source": [
    "您会注意到工具栏中的两个按钮：“+ 代码”和“+ 文本”。 它们分别用于创建可执行的 Python 代码单元和注释文本单元。 在代码单元格中输入代码后，点击Shift+Enter将执行它，像这样："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lucky-proportion",
   "metadata": {},
   "source": [
    "![](https://tva1.sinaimg.cn/large/008i3skNgy1gsmrd4g9dtj31aw0k4dhr.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "serious-orientation",
   "metadata": {},
   "source": [
    "在文本单元格中，您可以使用 Markdown 语法（见图 3.4）。 在文本移位输入单元格上点击Shift+Enter将呈现它。："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "collaborative-immunology",
   "metadata": {},
   "source": [
    "![](https://tva1.sinaimg.cn/large/008i3skNgy1gsmre6mh15j31c80tcwh9.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "little-virginia",
   "metadata": {},
   "source": [
    "文本单元格可用于为您的笔记本提供可读结构：使用它们为您的代码添加部分标题、长解释段落或嵌入数字。 笔记本是一种多媒体体验！"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unexpected-residence",
   "metadata": {},
   "source": [
    "**使用 PIP 安装软件包**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "returning-spread",
   "metadata": {},
   "source": [
    "默认的 Colab 环境已经安装了 TensorFlow 和 Keras，因此您无需任何安装步骤即可立即开始使用。 但是，如果您需要使用 安装某些东西，您可以通过在代码单元格中使用以下语法来实现（请注意，pip 行以 , 开头，表示它是一个 shell 命令而不是 Python 代码）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "finite-anger",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mWARNING: Ignoring invalid distribution -rpcio (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -f-nightly-gpu (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -rpcio (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -f-nightly-gpu (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "Looking in indexes: https://pypi.douban.com/simple\n",
      "Collecting package_name\n",
      "  Downloading https://pypi.doubanio.com/packages/61/5f/6690d5f0bad41818063e3f436c101deff0f243adede1d23642deb607349d/package_name-0.1.tar.gz (782 bytes)\n",
      "Building wheels for collected packages: package-name\n",
      "  Building wheel for package-name (setup.py) ... \u001b[?25ldone\n",
      "\u001b[?25h  Created wheel for package-name: filename=package_name-0.1-py3-none-any.whl size=1267 sha256=e62af97569f2a96e6809f2c5144895dbacc1fa9aafb3eb2e85252309a6d686e9\n",
      "  Stored in directory: /home/huangwei/.cache/pip/wheels/f0/a3/8f/8e652cfb05a64c109d7c2401a8d27f89e84f1e096ced089e22\n",
      "Successfully built package-name\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -rpcio (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -f-nightly-gpu (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "Installing collected packages: package-name\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -rpcio (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -f-nightly-gpu (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "Successfully installed package-name-0.1\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -rpcio (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -f-nightly-gpu (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -rpcio (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "\u001b[33mWARNING: Ignoring invalid distribution -f-nightly-gpu (/public/huangwei/miniconda3/envs/tensorflow/lib/python3.8/site-packages)\u001b[0m\n",
      "time: 7.17 s (started: 2021-07-20 07:56:45 +08:00)\n"
     ]
    }
   ],
   "source": [
    "!pip install package_name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deluxe-philosophy",
   "metadata": {},
   "source": [
    "**使用 GPU 运行时间**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "insured-progress",
   "metadata": {},
   "source": [
    "要在 Colab 中使用 GPU 运行时，请转到“运行时”→“更改运行时类型”，然后选择“GPU”（见图 3.5）。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "related-warrior",
   "metadata": {},
   "source": [
    "![](https://tva1.sinaimg.cn/large/008i3skNgy1gsmrgqh04ij314g0r2taf.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tropical-facing",
   "metadata": {},
   "source": [
    "如果 GPU 可用，TensorFlow 和 Keras 将自动在 GPU 上执行，因此在选择 GPU 运行时后您无需再执行任何操作。 您会注意到“硬件加速器”下拉菜单中还有一个 TPU 运行时选项。 与 GPU 运行时不同，将 TPU 运行时与 TensorFlow 和 Keras 结合使用确实需要在代码中进行一些手动设置。 我们将在第 13 章中介绍这一点。\n",
    "\n",
    "目前，我们建议您坚持使用 GPU 运行时来遵循本书中的代码示例。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bigger-prize",
   "metadata": {},
   "source": [
    "您现在可以开始在实践中运行 Keras 代码了。 接下来，让我们看看您在第 2 章中学到的关键思想如何转化为 Keras 和 TensorFlow 代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thrown-pavilion",
   "metadata": {},
   "source": [
    "## 使用 TensorFlow 的第一步"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aware-norfolk",
   "metadata": {},
   "source": [
    "正如您在前几章中看到的，训练神经网络围绕以下概念：\n",
    "\n",
    "首先，低级张量操作——所有现代机器学习的基础架构。 这转化为 TensorFlow API：\n",
    "* 张量，包括存储网络状态 ( ) 变量的特殊张量\n",
    "* 加法、relu、matmul等张量运算\n",
    "*反向传播，一种计算数学表达式梯度的方法（在 TensorFlow 中通过 GradientTape 对象处理）"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "paperback-importance",
   "metadata": {},
   "source": [
    "第二，高级深度学习概念。 这转化为 Keras API：\n",
    "* 层，它们组合成一个模型\n",
    "* 一个损失函数，它定义了用于学习的反馈信号\n",
    "* 一个优化器 ，它决定了学习如何进行优化器\n",
    "* 评估模型性能的指标，例如准确性\n",
    "* 执行小批量随机梯度下降的训练循环"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "located-phone",
   "metadata": {},
   "source": [
    "在上一章中，您已经初步接触了一些相应的 TensorFlow 和 Keras API：您已经简要地使用了 TensorFlow 的 Variable 类、matmul 操作和 GradientTape。 您已经实例化了 Keras Dense 层，将它们打包到一个 Sequential 模型中，并使用 fit 方法训练该模型。\n",
    "\n",
    "现在，让我们深入探讨如何使用 TensorFlow 和 Keras 在实践中处理上述所有不同概念。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prostate-kentucky",
   "metadata": {},
   "source": [
    "**常数张量和变量**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "published-waters",
   "metadata": {},
   "source": [
    "要在 TensorFlow 中做任何事情，我们需要一些张量。 张量需要用一些初始值创建，所以创建张量的常用方法是："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "twelve-saskatchewan",
   "metadata": {},
   "source": [
    "> 清单 3.1 全一或全零张量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "catholic-spanish",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[1.]\n",
      " [1.]], shape=(2, 1), dtype=float32)\n",
      "time: 6 ms (started: 2021-07-20 17:35:45 +08:00)\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "x = tf.ones(shape=(2, 1)) \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "asian-queen",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 1), dtype=float32, numpy=\n",
       "array([[0.],\n",
       "       [0.]], dtype=float32)>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 12 ms (started: 2021-07-20 17:36:05 +08:00)\n"
     ]
    }
   ],
   "source": [
    "x = tf.zeros(shape=(2, 1))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "raised-subcommittee",
   "metadata": {},
   "source": [
    "> 清单 3.2 随机张量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "distinct-amsterdam",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 1), dtype=float32, numpy=\n",
       "array([[ 0.11833647],\n",
       "       [-0.53093547],\n",
       "       [-0.6279465 ]], dtype=float32)>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 4.94 ms (started: 2021-07-20 17:39:23 +08:00)\n"
     ]
    }
   ],
   "source": [
    "# 从均值为 0 和标准差为 1 的正态分布中抽取的随机值张量。\n",
    "# 相当于 np.random.normal(size=(3, 1), loc=0., scale=1.)。\n",
    "x = tf.random.normal(shape=(3, 1), mean=0., stddev=1.)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "internal-collection",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(3, 1), dtype=float32, numpy=\n",
       "array([[0.95609   ],\n",
       "       [0.17031908],\n",
       "       [0.7562015 ]], dtype=float32)>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 8.35 ms (started: 2021-07-20 17:39:58 +08:00)\n"
     ]
    }
   ],
   "source": [
    "#从 0 和 1 之间的均匀分布中抽取的随机值张量。\n",
    "# 相当于 np.random.uniform(size=(3, 1), low=0., high=1.)。\n",
    "x = tf.random.uniform(shape=(3, 1), minval=0., maxval=1.)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "inner-anthropology",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[0.16544342]\n",
      " [0.18660843]\n",
      " [0.32238173]], shape=(3, 1), dtype=float32)\n",
      "time: 1.32 ms (started: 2021-07-20 17:38:03 +08:00)\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "minus-advocacy",
   "metadata": {},
   "source": [
    "NumPy 数组和 TensorFlow 张量之间的显着区别在于 TensorFlow 张量不可分配：它们是常数。 例如，在 NumPy 中，您可以执行以下操作："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seventh-testing",
   "metadata": {},
   "source": [
    "> 清单 3.3 NumPy 数组是可赋值的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "suburban-sleep",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 471 µs (started: 2021-07-20 17:41:16 +08:00)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.ones(shape=(2, 2))\n",
    "x[0, 0] = 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "studied-domain",
   "metadata": {},
   "source": [
    "尝试在 TensorFlow 中做同样的事情：你会得到一个错误，“EagerTensor 对象不支持项目分配”。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "visible-innocent",
   "metadata": {},
   "source": [
    "> 清单 3.4 TensorFlow 张量不可分配"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "formed-swing",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tensorflow.python.framework.ops.EagerTensor' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-09deea229eff>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tensorflow.python.framework.ops.EagerTensor' object does not support item assignment"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 123 ms (started: 2021-07-20 17:42:01 +08:00)\n"
     ]
    }
   ],
   "source": [
    "x = tf.ones(shape=(2, 2))\n",
    "x[0, 0] = 0."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bottom-pepper",
   "metadata": {},
   "source": [
    "为了训练一个模型，我们需要更新它的状态，它是一组张量。 如果张量不可赋值，那我们怎么做呢？ 这就是变量的用武之地。 tf.Variable 是用于管理 TensorFlow 中可修改状态的类。 您已经在第 2 章末尾的训练循环实现中简要地看到了它的实际作用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "efficient-ridge",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Variable:0' shape=(3, 1) dtype=float32, numpy=\n",
       "array([[ 0.64557743],\n",
       "       [ 1.7590712 ],\n",
       "       [-0.0507943 ]], dtype=float32)>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 9.63 ms (started: 2021-07-20 17:42:50 +08:00)\n"
     ]
    }
   ],
   "source": [
    "v = tf.Variable(initial_value=tf.random.normal(shape=(3, 1)))\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unlimited-international",
   "metadata": {},
   "source": [
    "可以通过其方法修改变量的状态：assign"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "welsh-secondary",
   "metadata": {},
   "source": [
    "> 清单 3.6 为变量赋值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "grateful-prospect",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'UnreadVariable' shape=(3, 1) dtype=float32, numpy=\n",
       "array([[1.],\n",
       "       [1.],\n",
       "       [1.]], dtype=float32)>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 14.1 ms (started: 2021-07-20 17:44:01 +08:00)\n"
     ]
    }
   ],
   "source": [
    "v.assign(tf.ones((3, 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "gross-crazy",
   "metadata": {},
   "source": [
    "它也适用于系数的子集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "severe-shade",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'UnreadVariable' shape=(3, 1) dtype=float32, numpy=\n",
       "array([[3.],\n",
       "       [1.],\n",
       "       [1.]], dtype=float32)>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 16.3 ms (started: 2021-07-20 17:44:35 +08:00)\n"
     ]
    }
   ],
   "source": [
    "v[0, 0].assign(3.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "humanitarian-header",
   "metadata": {},
   "source": [
    "类似地，assign_add和assign_sub and 是  +=和-= 的有效等价物："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "billion-keeping",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'UnreadVariable' shape=(3, 1) dtype=float32, numpy=\n",
       "array([[4.],\n",
       "       [2.],\n",
       "       [2.]], dtype=float32)>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 13.2 ms (started: 2021-07-20 17:47:24 +08:00)\n"
     ]
    }
   ],
   "source": [
    "v.assign_add(tf.ones((3, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "encouraging-consortium",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'UnreadVariable' shape=(3, 1) dtype=float32, numpy=\n",
       "array([[3.],\n",
       "       [1.],\n",
       "       [1.]], dtype=float32)>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 4.66 ms (started: 2021-07-20 17:47:33 +08:00)\n"
     ]
    }
   ],
   "source": [
    "v.assign_sub(tf.ones((3, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "reported-cosmetic",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Variable 'Variable:0' shape=(3, 1) dtype=float32, numpy=\n",
       "array([[3.],\n",
       "       [1.],\n",
       "       [1.]], dtype=float32)>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 2.37 ms (started: 2021-07-20 17:47:35 +08:00)\n"
     ]
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "married-locator",
   "metadata": {},
   "source": [
    "**张量操作：在张量流中做数学运算**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mysterious-breakfast",
   "metadata": {},
   "source": [
    "就像 NumPy 一样，TensorFlow 提供了大量张量运算来表达数学公式。 这里有一些例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "advisory-patrol",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[1., 1.],\n",
       "       [1., 1.]], dtype=float32)>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 7.37 ms (started: 2021-07-20 17:48:51 +08:00)\n"
     ]
    }
   ],
   "source": [
    "a = tf.ones((2, 2))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "essential-least",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[1., 1.],\n",
       "       [1., 1.]], dtype=float32)>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 4.5 ms (started: 2021-07-20 17:48:57 +08:00)\n"
     ]
    }
   ],
   "source": [
    "b = tf.square(a) \n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "innocent-topic",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[1., 1.],\n",
       "       [1., 1.]], dtype=float32)>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 8.67 ms (started: 2021-07-20 17:49:27 +08:00)\n"
     ]
    }
   ],
   "source": [
    "c = tf.sqrt(a) \n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "infectious-authentication",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[2., 2.],\n",
       "       [2., 2.]], dtype=float32)>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 6.12 ms (started: 2021-07-20 17:49:33 +08:00)\n"
     ]
    }
   ],
   "source": [
    "d = b + c \n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "digital-listening",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[2., 2.],\n",
       "       [2., 2.]], dtype=float32)>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1.81 s (started: 2021-07-20 17:49:50 +08:00)\n"
     ]
    }
   ],
   "source": [
    "e = tf.matmul(a, b) \n",
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "saving-elite",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[2., 2.],\n",
       "       [2., 2.]], dtype=float32)>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 2.49 ms (started: 2021-07-20 17:49:57 +08:00)\n"
     ]
    }
   ],
   "source": [
    "a@b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "opposite-bolivia",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n",
       "array([[4., 4.],\n",
       "       [4., 4.]], dtype=float32)>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 4.54 ms (started: 2021-07-20 17:50:11 +08:00)\n"
     ]
    }
   ],
   "source": [
    "e *= d\n",
    "e"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mechanical-asset",
   "metadata": {},
   "source": [
    "重要的是，我们刚刚编写的每个操作都会即时执行：在任何时候，您都可以打印当前结果，就像在 NumPy 中一样。 我们称之为急切执行。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acknowledged-complaint",
   "metadata": {},
   "source": [
    "**再看一下 GradientTape API**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "qualified-realtor",
   "metadata": {},
   "source": [
    "到目前为止，TensorFlow 看起来很像 NumPy。 但 NumPy 无法做到这一点：检索任何可微表达式相对于其任何输入的梯度。 只需打开一个 GradientTape 范围，对一个或多个输入张量应用一些计算，并检索结果相对于输入的梯度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "satisfactory-fleece",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=float32, numpy=6.0>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 6.55 ms (started: 2021-07-20 17:52:29 +08:00)\n"
     ]
    }
   ],
   "source": [
    "input_var = tf.Variable(initial_value=3.)\n",
    "with tf.GradientTape() as tape:\n",
    "    result = tf.square(input_var)\n",
    "gradient = tape.gradient(result, input_var)\n",
    "gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "raising-indian",
   "metadata": {},
   "source": [
    "这最常用于检索模型相对于其权重的损失梯度：gradients = tape.gradient(loss, weights)。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "proprietary-procurement",
   "metadata": {},
   "source": [
    "在第 2 章中，您已经看到 GradientTape 如何处理单个输入或输入列表，以及输入如何可以是标量或高维张量。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alert-angel",
   "metadata": {},
   "source": [
    "到目前为止，您只看到了 tape.gradient() 中的输入张量是 TensorFlow 变量的情况。 这些输入实际上可能是任意张量。 但是，默认情况下只跟踪可训练的变量。 使用常量张量，您必须手动将其标记为正在跟踪，方法是在其上调用 tape.watch()："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "received-hampton",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 5.63 ms (started: 2021-07-20 17:56:02 +08:00)\n"
     ]
    }
   ],
   "source": [
    "input_const = tf.constant(3.)\n",
    "with tf.GradientTape() as tape:\n",
    "    tape.watch(input_const)\n",
    "    result = tf.square(input_const)\n",
    "gradient = tape.gradient(result, input_const)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "lovely-merit",
   "metadata": {},
   "source": [
    "为什么？ 因为抢先存储计算任何事物相对于任何事物的梯度所需的信息太昂贵了。 为避免浪费资源，磁带需要知道该看什么。 默认情况下会监视可训练变量，因为计算关于可训练变量列表的损失梯度是梯度磁带最常见的用例。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adverse-discount",
   "metadata": {},
   "source": [
    "梯度带是一个强大的工具，甚至能够计算二阶梯度，即梯度的梯度。 例如，一个物体的位置相对于时间的梯度就是这个物体的速度，二阶梯度就是它的加速度。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "communist-township",
   "metadata": {},
   "source": [
    "如果你随时间测量一个下落的苹果在垂直轴上的位置，发现它验证了 position(time) = 4.9 * time ** 2，它的加速度是多少？ 让我们使用两个嵌套的渐变磁带来找出答案。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "introductory-color",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 13.3 ms (started: 2021-07-20 17:58:17 +08:00)\n"
     ]
    }
   ],
   "source": [
    "time = tf.Variable(0.)\n",
    "with tf.GradientTape() as outer_tape:\n",
    "    with tf.GradientTape() as inner_tape:\n",
    "        position = 4.9 * time ** 2\n",
    "    speed = inner_tape.gradient(position, time)\n",
    "acceleration = outer_tape.gradient(speed, time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "greater-edmonton",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(), dtype=float32, numpy=9.8>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1.95 ms (started: 2021-07-20 17:58:23 +08:00)\n"
     ]
    }
   ],
   "source": [
    "acceleration"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interracial-gardening",
   "metadata": {},
   "source": [
    "**端到端示例：纯张量流中的线性分类器**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "disabled-compilation",
   "metadata": {},
   "source": [
    "您了解张量、变量、张量运算，并且您知道如何计算梯度。 这足以构建任何基于梯度下降的机器学习模型。 而你只是在第 3 章！\n",
    "\n",
    "在机器学习工作面试中，您可能会被要求在 TensorFlow 中从头开始实现一个线性分类器：这是一项非常简单的任务，可在具有一些机器学习背景的候选人和没有机器学习背景的候选人之间进行筛选。 让我们让您通过过滤器，并使用您对 TensorFlow 的新知识来实现这样一个线性分类器。\n",
    "\n",
    "首先，让我们想出一些很好的线性可分合成数据来处理：二维平面中的两类点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "continuing-twenty",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1.84 ms (started: 2021-07-20 18:06:15 +08:00)\n"
     ]
    }
   ],
   "source": [
    "num_samples_per_class = 1000\n",
    "\n",
    "# 生成第一类点：1000 个具有指定“均值”和“协方差矩阵”的随机二维点。 \n",
    "# 直观上，“协方差矩阵”描述了下图中点云的形状，“均值”描述了它在平面中的位置。 \n",
    "# cov=[[1, 0.5],[0.5, 1]] 对应于“一个从左下角到右上角的椭圆形点云”。\n",
    "negative_samples = np.random.multivariate_normal(\n",
    "    mean=[0, 3], cov=[[1, 0.5],[0.5, 1]], size=num_samples_per_class) \n",
    "\n",
    "# 生成具有差异均值和相同协方差矩阵的另一类点（具有不同位置和相同形状的点云）。\n",
    "positive_samples = np.random.multivariate_normal(\n",
    "    mean=[3, 0], cov=[[1, 0.5],[0.5, 1]], size=num_samples_per_class)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "complimentary-studio",
   "metadata": {},
   "source": [
    "negative_samples 和 positive_samples 都是具有 shape 的数组。 让我们将 (1000, 2) 它们堆叠成一个形状为 (2000, 2) 的数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "proof-drilling",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 551 µs (started: 2021-07-20 18:07:03 +08:00)\n"
     ]
    }
   ],
   "source": [
    "inputs = np.vstack((negative_samples, positive_samples)).astype(np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "handmade-chapter",
   "metadata": {},
   "source": [
    "让我们生成相应的目标标签，一个由 0 和 1 组成的形状为 (2000, 1) 的数组，其中如果属于 0 类（反之亦然），则 target[i, 0] 输入 [i] 为 0："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "hydraulic-agent",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1.74 ms (started: 2021-07-21 12:26:45 +08:00)\n"
     ]
    }
   ],
   "source": [
    "targets = np.vstack((np.zeros((num_samples_per_class, 1), dtype=\"float32\"),\n",
    "                     np.ones((num_samples_per_class, 1), dtype=\"float32\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "stock-opportunity",
   "metadata": {},
   "source": [
    "让我们用 Matplotlib 绘制我们的数据，这是一个著名的 Python 数据可视化库（它预装在 Colab 中，因此您无需自己安装）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "turkish-modification",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 743 ms (started: 2021-07-21 12:27:20 +08:00)\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.scatter(inputs[:, 0], inputs[:, 1], c=targets[:, 0])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afraid-houston",
   "metadata": {},
   "source": [
    "现在，让我们创建一个可以学习分离这两个 blob 的线性分类器。 线性分类器是经过训练的仿射变换（预测 = W • 输入 + b）以最小化预测与目标之间的差异的平方。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "greenhouse-hardware",
   "metadata": {},
   "source": [
    "正如您将看到的，它实际上是一个比第 2 章末尾的玩具两层神经网络的端到端示例简单得多的示例。 但是，这一次，您应该能够理解有关代码的所有内容 ， 逐行。\n",
    "\n",
    "让我们创建变量，并分别用随机值和零初始化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "friendly-relevance",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 12.9 ms (started: 2021-07-21 12:31:20 +08:00)\n"
     ]
    }
   ],
   "source": [
    "input_dim = 2 \n",
    "output_dim = 1 \n",
    "W = tf.Variable(initial_value=tf.random.uniform(shape=(input_dim, output_dim)))\n",
    "b = tf.Variable(initial_value=tf.zeros(shape=(output_dim,)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "second-liverpool",
   "metadata": {},
   "source": [
    "这是我们的前向传递函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "precious-building",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 714 µs (started: 2021-07-21 12:32:26 +08:00)\n"
     ]
    }
   ],
   "source": [
    "def model(inputs):\n",
    "    return tf.matmul(inputs, W) + b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blessed-brooks",
   "metadata": {},
   "source": [
    "因为我们的线性分类器对 2D 输入进行操作，实际上只是两个标量系数 w1 和 w2 W2:W = [[w1], [w2]]。同时， 是单个标量系数。 因此，对于给定的输入 b\n",
    "point ，它的预测值为：[x, y] prediction = [[w1], [w2]] • [x, y] + b = w1 * x + w2 * y + b。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "warming-depth",
   "metadata": {},
   "source": [
    "这是我们的损失函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "technological-assessment",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 763 µs (started: 2021-07-21 12:42:31 +08:00)\n"
     ]
    }
   ],
   "source": [
    "def square_loss(targets, predictions):\n",
    "    per_sample_losses = tf.square(targets - predictions) \n",
    "    return tf.reduce_mean(per_sample_losses)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "comfortable-cambodia",
   "metadata": {},
   "source": [
    "现在，训练步骤，它接收一些训练数据并更新权重 W 和 b 以最小化数据的损失："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "fuzzy-council",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1.06 ms (started: 2021-07-21 12:44:47 +08:00)\n"
     ]
    }
   ],
   "source": [
    "learning_rate = 0.1\n",
    "def training_step(inputs, targets):\n",
    "    with tf.GradientTape() as tape:\n",
    "        predictions = model(inputs)\n",
    "        loss = square_loss(predictions, targets) \n",
    "    grad_loss_wrt_W, grad_loss_wrt_b = tape.gradient(loss, [W, b]) \n",
    "    W.assign_sub(grad_loss_wrt_W * learning_rate)\n",
    "    b.assign_sub(grad_loss_wrt_b * learning_rate)\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prepared-ladder",
   "metadata": {},
   "source": [
    "为简单起见，我们将进行批量训练，而不是小批量训练：我们将在整个数据上运行每个训练步骤（梯度计算和权重更新），而不是小批量迭代数据。 一方面，这意味着每个训练步骤都需要更长的时间来运行，因为我们一次计算了 2000 个样本的前向传播和梯度。 另一方面，每次梯度更新将更有效地减少训练数据的损失，因为它将包含来自所有训练样本的信息，而不是仅 128 个随机样本。 因此，我们将需要更少的训练步骤，并且我们应该使用比我们通常用于小批量训练的学习率更大的学习率（我们将使用 learning_rate = 0.1，如上定义）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "matched-claim",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss at step 0: 1.1959\n",
      "Loss at step 1: 0.1469\n",
      "Loss at step 2: 0.1014\n",
      "Loss at step 3: 0.0909\n",
      "Loss at step 4: 0.0847\n",
      "Loss at step 5: 0.0794\n",
      "Loss at step 6: 0.0746\n",
      "Loss at step 7: 0.0703\n",
      "Loss at step 8: 0.0663\n",
      "Loss at step 9: 0.0627\n",
      "Loss at step 10: 0.0594\n",
      "Loss at step 11: 0.0564\n",
      "Loss at step 12: 0.0537\n",
      "Loss at step 13: 0.0512\n",
      "Loss at step 14: 0.0489\n",
      "Loss at step 15: 0.0468\n",
      "Loss at step 16: 0.0450\n",
      "Loss at step 17: 0.0432\n",
      "Loss at step 18: 0.0417\n",
      "Loss at step 19: 0.0402\n",
      "Loss at step 20: 0.0389\n",
      "Loss at step 21: 0.0377\n",
      "Loss at step 22: 0.0367\n",
      "Loss at step 23: 0.0357\n",
      "Loss at step 24: 0.0348\n",
      "Loss at step 25: 0.0339\n",
      "Loss at step 26: 0.0332\n",
      "Loss at step 27: 0.0325\n",
      "Loss at step 28: 0.0319\n",
      "Loss at step 29: 0.0313\n",
      "Loss at step 30: 0.0308\n",
      "Loss at step 31: 0.0303\n",
      "Loss at step 32: 0.0299\n",
      "Loss at step 33: 0.0295\n",
      "Loss at step 34: 0.0292\n",
      "Loss at step 35: 0.0288\n",
      "Loss at step 36: 0.0285\n",
      "Loss at step 37: 0.0283\n",
      "Loss at step 38: 0.0280\n",
      "Loss at step 39: 0.0278\n",
      "time: 322 ms (started: 2021-07-21 12:47:36 +08:00)\n"
     ]
    }
   ],
   "source": [
    "for step in range(40):\n",
    "    loss = training_step(inputs, targets)\n",
    "    print(f\"Loss at step {step}: {loss:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "auburn-daily",
   "metadata": {},
   "source": [
    "40 步后，训练损失似乎稳定在 0.025 左右。 让我们绘制我们的线性模型如何对训练数据点进行分类。 因为我们的目标是 0 和 1，如果预测值低于 0.5，给定的输入点将被归类为“0”，如果它高于 0.5，则被归类为“1”："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "rational-advocacy",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 181 ms (started: 2021-07-21 12:49:53 +08:00)\n"
     ]
    }
   ],
   "source": [
    "predictions = model(inputs)\n",
    "plt.scatter(inputs[:, 0], inputs[:, 1], c=predictions[:, 0] > 0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "united-basket",
   "metadata": {},
   "source": [
    "回想一下，给定点的预测值只是 [x, y] 预测 == [[w1], [w2]] • [x, y] + b == w1 * x + w2 * y + b。因此，“0”类定义为：w1 * x + w2* y + b < 0.5，“1”类定义为：w1 * x + w2 * y + b > 0.5。 您会注意到您所看到的实际上是 2D 平面中一条直线的方程：w1 * x + w2 * y + b = 0.5。在线上方为 1 类，线下方为 0 类。您可能习惯于以 y = a * x + b; 格式查看线方程。 以相同的格式，我们的行变成：y = - w1 / w2 * x +(0.5 - b) / w2。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ready-valve",
   "metadata": {},
   "source": [
    "让我们绘制这条线："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "early-syndication",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f62d813de50>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 192 ms (started: 2021-07-21 12:52:04 +08:00)\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(-1, 4, 100) \n",
    "y = - W[0] / W[1] * x + (0.5 - b) / W[1] \n",
    "plt.plot(x, y, \"-r\") \n",
    "plt.scatter(inputs[:, 0], inputs[:, 1], c=predictions[:, 0] > 0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "organizational-stephen",
   "metadata": {},
   "source": [
    "这就是线性分类器的真正意义所在：找到一条直线（或者，在高维空间中，一个超平面）的参数，将两类数据巧妙地分开。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fancy-given",
   "metadata": {},
   "source": [
    "## 神经网络剖析：了解核心 Keras API"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "regulated-qualification",
   "metadata": {},
   "source": [
    "至此，您已经了解了 TensorFlow 的基础知识，并且可以使用它从头开始实现一个玩具模型，例如上面的批线性分类器，或者第 2 章末尾的玩具神经网络。 这是一个坚实的基础 . 现在是时候转向更高效、更稳健的深度学习路径了：Keras API。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accredited-recruitment",
   "metadata": {},
   "source": [
    "### 层：深度学习的基石"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "certain-basketball",
   "metadata": {},
   "source": [
    "层神经网络中的基本数据结构是 ，在第 2 中介绍了它。层是一个数据处理模块，它以一个或多个张量作为输入并输出一个或多个张量。 有些层是无状态的，但更常见的是层有一个状态：该层的 ，一个或几个通过随机梯度下降学习的张量，它们的权重一起包含网络的知识。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "greatest-asthma",
   "metadata": {},
   "source": [
    "不同类型的层适用于不同的张量格式和不同类型的数据处理。 例如，存储在二维形状张量（样本、特征）中的简单矢量数据通常由密集连接层处理，也称为全连接密集层（Keras 中的类）。 序列数据存储在形状为 Dense（样本、时间步长、特征）的 3D 张量中，通常由层处理，例如层或循环 LSTM 1D 卷积层 Conv1D()。 存储在 4D 张量中的图像数据通常由 2D Conv1D() 卷积层处理。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "remarkable-insulation",
   "metadata": {},
   "source": [
    "您可以将层视为深度学习的乐高积木，这是 Keras 明确表达的隐喻。 在 Keras 中构建深度学习模型是通过将兼容层剪辑在一起来完成的形成有用的数据转换管道。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "foreign-potato",
   "metadata": {},
   "source": [
    "**KERAS 中的基础类**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unlike-letter",
   "metadata": {},
   "source": [
    "一个简单的 API 应该有一个单一的抽象，一切都围绕着它。 在 Keras 中，这就是类。 Keras 中的一切要么是一个层，要么是层与层紧密交互的东西。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "posted-onion",
   "metadata": {},
   "source": [
    "层是封装了一些状态（权重）和一些计算（前向传递）的对象。 权重通常在 build() 中定义（尽管它们也可以在构造函数 init() 中创建），并且计算在call()方法中定义。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fresh-candy",
   "metadata": {},
   "source": [
    "在上一章中，我们实现了一个包含两个权重 W 和 b 的 NaiveDense 类，并应用了计算 output = activation(dot(input, W) + b)。 这是同一层在 Keras 中的样子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "direct-calculation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1.34 ms (started: 2021-07-22 11:04:22 +08:00)\n"
     ]
    }
   ],
   "source": [
    "from tensorflow import keras\n",
    "\n",
    "# 所有 Keras 层都继承自基类。\n",
    "class SimpleDense(keras.layers.Layer): \n",
    "    \n",
    "    def __init__(self, units, activation=None):\n",
    "        super().__init__()\n",
    "        self.units = units\n",
    "        self.activation = activation\n",
    "        \n",
    "    #权重创建发生在该方法中。    \n",
    "    def build(self, input_shape):\n",
    "        input_dim = input_shape[-1]\n",
    "        \n",
    "        # add_weight 是创建权重的快捷方法。 \n",
    "        # 也可以创建独立变量并将它们分配为层属性，\n",
    "        # 例如：self.W = tf.Variable(tf.random.uniform(w_shape))。\n",
    "        self.W = self.add_weight(shape=(input_dim, self.units), \n",
    "        initializer=\"random_normal\")\n",
    "        self.b = self.add_weight(shape=(self.units,),\n",
    "        initializer=\"zeros\")\n",
    "        \n",
    "        #我们在方法中定义了前向传递计算。\n",
    "    def call(self, inputs):\n",
    "        y = tf.matmul(inputs, self.W) + self.b\n",
    "        if self.activation is not None:\n",
    "            y = self.activation(y)\n",
    "        return y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "raising-flight",
   "metadata": {},
   "source": [
    "在下一节中，我们将详细介绍这些 build() 和 call() 方法的用途。 如果您还不了解所有内容，请不要担心！"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accepted-consortium",
   "metadata": {},
   "source": [
    "一旦实例化，这样的层就可以像函数一样使用，将 TensorFlow 张量作为输入："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "polish-tunisia",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 12.8 ms (started: 2021-07-21 13:26:14 +08:00)\n"
     ]
    }
   ],
   "source": [
    "my_dense = SimpleDense(units=32, activation=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "multiple-testament",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 9.49 ms (started: 2021-07-21 13:26:26 +08:00)\n"
     ]
    }
   ],
   "source": [
    "input_tensor = tf.ones(shape=(2, 784))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "royal-printing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([2, 32])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 16.5 ms (started: 2021-07-21 13:26:46 +08:00)\n"
     ]
    }
   ],
   "source": [
    "output_tensor = my_dense(input_tensor)\n",
    "output_tensor.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "going-bulgaria",
   "metadata": {},
   "source": [
    "现在，您可能想知道，为什么我们必须实现call() 和 build() ，因为我们最终通过简单地调用它来使用我们的层，也就是说，通过使用它的方法？ 这是调用，因为我们希望能够及时创建状态。 让我们看看它是如何工作的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intensive-meditation",
   "metadata": {},
   "source": [
    "**自动形状推理：动态构建层**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exempt-shark",
   "metadata": {},
   "source": [
    "就像乐高积木一样，您只能将这里的兼容性层组装在一起。概念兼容特指这样一个事实，即每一层只接受某种形状的输入张量，并返回某种形状的输出张量。 考虑以下示例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "subject-thumbnail",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 3.04 ms (started: 2021-07-22 11:04:16 +08:00)\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras import layers\n",
    "layer = layers.Dense(32, activation=\"relu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "floppy-analyst",
   "metadata": {},
   "source": [
    "该层将返回一个张量，其中第一维已转换为 32。它只能连接到期望 32 维向量作为其输入的下游层。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efficient-tobago",
   "metadata": {},
   "source": [
    "使用 Keras 时，大多数时候您不必担心尺寸兼容性，因为您添加到模型中的层是动态构建的，以匹配传入层的形状。 例如，假设您编写以下内容："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "hindu-piece",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1.72 s (started: 2021-07-22 11:04:11 +08:00)\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras import models\n",
    "from tensorflow.keras import layers\n",
    "model = models.Sequential([\n",
    "    layers.Dense(32, activation=\"relu\", input_shape=(20,)),\n",
    "    layers.Dense(32)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "technical-shelter",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_3 (Dense)              (None, 32)                672       \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 32)                1056      \n",
      "=================================================================\n",
      "Total params: 1,728\n",
      "Trainable params: 1,728\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "time: 2.18 ms (started: 2021-07-21 13:36:55 +08:00)\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "found-birth",
   "metadata": {},
   "source": [
    "这些层没有收到有关其输入形状的任何信息——相反，它们会自动将其输入形状推断为它们看到的第一个输入的形状。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "searching-terrain",
   "metadata": {},
   "source": [
    "在我们在第 2 章中实现的Dense层的玩具版本中（我们将其命名为 NaiveDense），我们必须将层的输入大小显式传递给构造函数，以便\n",
    "能够创建它的权重。 这并不理想，因为它会导致模型看起来像这样，每个新层都需要知道它之前的层的形状："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "published-affairs",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = NaiveSequential([\n",
    "    NaiveDense(input_size=784, output_size=32, activation=\"relu\"),\n",
    "    NaiveDense(input_size=32, output_size=64, activation=\"relu\"),\n",
    "    NaiveDense(input_size=64, output_size=32, activation=\"relu\"),\n",
    "    NaiveDense(input_size=32, output_size=10, activation=\"softmax\")\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "internal-admission",
   "metadata": {},
   "source": [
    "当一个层用来产生其输出形状的规则很复杂时，情况会更糟。 例如，如果我们的层返回形状的输出（batch, input_size * 2 if input_size % 2 == 0 else input_size * 3）怎么办？"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "religious-course",
   "metadata": {},
   "source": [
    "如果我们将 NaiveDense 层重新实现为能够自动进行形状推断的 Keras 层，它会更简单，就像上面的 SimpleDense 层（请参阅代码块 TODO）及其方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "crazy-xerox",
   "metadata": {},
   "source": [
    "在 SimpleDense 中，我们不再像在 NaiveDense 示例中那样在构造函数中创建权重，而是在专用的状态创建方法中创建它们，该方法接收 build() 作为层看到的第一个输入形状的参数。 该方法在第一次调用层时自动调用 build()（通过它的 call() 方法）。 事实上，这就是为什么我们在单独的 call() 方法中而不是直接在方法中定义计算！ 基础层的call()方法示意图如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "comprehensive-wisdom",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 755 µs (started: 2021-07-21 13:45:18 +08:00)\n"
     ]
    }
   ],
   "source": [
    "def __call__(self, inputs):\n",
    "    if not self.built:\n",
    "        self.build(inputs.shape)\n",
    "        self.built = True\n",
    "    return self.call(inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "broadband-borough",
   "metadata": {},
   "source": [
    "通过自动形状推断，我们之前的示例变得简单而整洁："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "serial-article",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = keras.Sequential([\n",
    "    SimpleDense(32, activation=\"relu\"),\n",
    "    SimpleDense(64, activation=\"relu\"),\n",
    "    SimpleDense(32, activation=\"relu\"),\n",
    "    SimpleDense(10, activation=\"softmax\")\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hybrid-zealand",
   "metadata": {},
   "source": [
    "请注意，自动形状推断并不是 Layer 类的 call() 方法处理的唯一内容。 它处理更多的事情，特别是在急切图执行之间的路由（您将在第 6 章中了解的概念）和输入屏蔽（我们将在第 11 章中介绍）。 现在，请记住：在实现您自己的层时，将前向传递放在 call() 方法中。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abstract-wisconsin",
   "metadata": {},
   "source": [
    "### 从层到模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "atomic-serve",
   "metadata": {},
   "source": [
    "深度学习模型是层的图。 在 Keras 中，这就是类。 现在，您只看到了 Model 序列模型（ 的子类），它们是简单的层堆栈，将 Model 的单个输入映射到单个输出。 但是随着您的前进，您将接触到更广泛的网络拓扑。 一些常见的有：\n",
    "* 两分支网络\n",
    "* 多头网络\n",
    "* 剩余连接"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dirty-bailey",
   "metadata": {},
   "source": [
    "网络拓扑可能会非常复杂。 例如，这是 Transformer 层图的拓扑结构，这是一种设计用于处理文本数据的通用架构："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "comprehensive-evening",
   "metadata": {},
   "source": [
    "##Figure 3.9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "roman-container",
   "metadata": {},
   "source": [
    "在 Keras 中构建这样的模型通常有两种方法：您可以直接继承 Model 类，或者您可以使用 Functional API，它可以让您用更少的代码做更多的事情。 我们将在第 7 章中介绍这两种方法。\n",
    "\n",
    "模型的拓扑定义了一个假设空间。 您可能还记得在第 1 章中，我们将机器学习描述为“使用来自反馈信号的指导，在预定义的可能性空间内搜索某些输入数据的有用表示”。 通过选择网络拓扑，您可以将可能性空间（假设空间）限制为一系列特定的张量运算，将输入数据映射到输出数据。 然后，您将搜索这些张量运算中涉及的权重张量的一组很好的值。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "latest-marine",
   "metadata": {},
   "source": [
    "要从数据中学习，您必须对其进行假设。 这些假设定义了可以学习的内容。 因此，假设空间的结构——模型的架构——极其重要。 它编码了您对问题所做的假设，即模型开始时的先验知识。 例如，如果您正在处理一个二分类问题，模型由单层组成，没有激活（纯 Dense\n",
    "仿射变换），您假设您的两个类是线性可分的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "japanese-harbor",
   "metadata": {},
   "source": [
    "选择正确的网络架构与其说是科学，不如说是一门艺术； 尽管有一些最佳实践和原则可供您信赖，但只有实践才能帮助您成为一名合适的神经网络架构师。 接下来的几章将教你构建神经网络的明确原则，并帮助你培养直觉，判断哪些对特定问题有效，哪些无效。 您将对哪种类型的模型架构适用于不同类型的问题、如何在实践中构建这些网络、如何选择正确的学习配置以及如何调整模型直到产生您想要的结果建立坚实的直觉。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "postal-nowhere",
   "metadata": {},
   "source": [
    "### “编译”步骤：配置学习过程"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tribal-brave",
   "metadata": {},
   "source": [
    "一旦定义了模型架构，您还需要再选择三件事：\n",
    "* 损失函数（目标函数）——在训练过程中将被最小化的数量。 它代表了手头任务成功的衡量标准。\n",
    "* 优化器——根据损失函数确定网络将如何更新。 它实现了随机梯度下降 (SGD) 的特定变体。\n",
    "* 指标 - 您希望在训练和验证期间监控的成功度量，例如分类准确性。 与损失不同，训练不会直接针对这些指标进行优化。 因此，指标不需要是可微的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prostate-suspect",
   "metadata": {},
   "source": [
    "一旦你选择了你的损失、优化器和指标，你就可以使用内置的 compile() 和 fit() 方法来开始训练你的模型。 或者，您也可以编写自己的自定义训练循环——我们将在第 6 章中介绍如何做到这一点。还有很多工作要做！ 现在，让我们看看 compile() 和 fit()。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mature-fraction",
   "metadata": {},
   "source": [
    "该方法配置了训练过程——您已经在第 2 章的第一个神经网络示例 compile() 中介绍了它。它采用参数：优化器loss和metrics（一个列表）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ultimate-acquisition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 294 ms (started: 2021-07-22 11:04:29 +08:00)\n"
     ]
    }
   ],
   "source": [
    "model = keras.Sequential([keras.layers.Dense(1)]) \n",
    "model.compile(optimizer=\"rmsprop\",\n",
    "              loss=\"mean_squared_error\",\n",
    "              metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "religious-visit",
   "metadata": {},
   "source": [
    "在上面对 compile() 的调用中，我们将优化器、损失和指标作为字符串（例如“rmsprop”）传递。 这些字符串实际上是转换为 Python 对象的快捷方式。 例如，“rmsprop”变为 keras.optimizers.RMSprop()。 重要的是，也可以将这些参数指定为对象实例，如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "quantitative-share",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 19.4 ms (started: 2021-07-22 11:04:31 +08:00)\n"
     ]
    }
   ],
   "source": [
    "model.compile(optimizer=keras.optimizers.RMSprop(),\n",
    "              loss=keras.losses.MeanSquaredError(),\n",
    "              metrics=[keras.metrics.BinaryAccuracy()])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "introductory-sword",
   "metadata": {},
   "source": [
    "如果您想传递自己的自定义损失或指标，或者如果您想进一步配置您正在使用的对象，这将非常有用——例如，通过将 learning_rate 参数传递给优化器："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "forty-holder",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=1e-4),\n",
    "              loss=my_custom_loss,\n",
    "              metrics=[my_custom_metric_1, my_custom_metric_2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "strategic-dialogue",
   "metadata": {},
   "source": [
    "在第 6 章中，我们将介绍如何创建自定义损失和指标。 一般来说，您不必从头开始创建自己的损失、指标或优化器，因为 Keras 提供了广泛的内置选项，可能包括您需要的内容："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "threaded-peoples",
   "metadata": {},
   "source": [
    "**Optimizers:**\n",
    "* SGD() (with or without momentum)\n",
    "* RMSprop()\n",
    "* Adam()\n",
    "* Adagrad()\n",
    "* Etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unsigned-laptop",
   "metadata": {},
   "source": [
    "**Losses:**\n",
    "* CategoricalCrossentropy()\n",
    "* SparseCategoricalCrossentropy()\n",
    "* BinaryCrossentropy()\n",
    "* MeanSquaredError()\n",
    "* KLDivergence()\n",
    "* CosineSimilarity()\n",
    "* Etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "impressed-phrase",
   "metadata": {},
   "source": [
    "**Metrics:**\n",
    "* CategoricalAccuracy()\n",
    "* SparseCategoricalAccuracy()\n",
    "* BinaryAccuracy()\n",
    "* AUC()\n",
    "* Precision()\n",
    "* Recall()\n",
    "* Etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "detected-window",
   "metadata": {},
   "source": [
    "在本书中，您将看到许多这些选项的具体应用。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "consecutive-account",
   "metadata": {},
   "source": [
    "### 选择一个损失函数"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "democratic-electric",
   "metadata": {},
   "source": [
    "为正确的问题选择正确的损失函数非常重要：您的网络将采取任何可能的捷径来最小化损失； 因此，如果目标与手头任务的成功不完全相关，您的网络最终会做您可能不想要的事情。 想象一个通过 SGD 训练的愚蠢的、全能的 AI，其目标函数选择不当：“最大化所有活着的人类的平均幸福感”。 为了让工作更轻松，这个 AI 可能会选择杀死除少数人之外的所有人类，并专注于其余人的福祉——因为平均福祉不受剩下多少人的影响。 这可能不是你想要的！ 请记住，您构建的所有神经网络在降低其损失函数方面都将同样无情——所以明智地选择目标，否则您将不得不面对意想不到的副作用。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "color-boxing",
   "metadata": {},
   "source": [
    "幸运的是，当涉及到分类、回归和序列预测等常见问题时，您可以遵循一些简单的指南来选择正确的损失。 例如，您将对二分类问题使用二元交叉熵，对多类分类问题使用分类交叉熵，等等。 只有当你在研究真正的新研究问题时，你才必须开发自己的损失函数。 在接下来的几章中，我们将明确详细说明为广泛的常见任务选择哪些损失函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "trained-investing",
   "metadata": {},
   "source": [
    "### 理解fit方法"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fitted-sociology",
   "metadata": {},
   "source": [
    "在 compile() 之后是 fit()。 该方法实现了训练循环本身。 它的关键拟合参数是：\n",
    "* 要训练的数据（输入和目标）。 它通常以NumPy 数组或 TensorFlow 对象的形式传递。 您将在下一章中了解有关 Dataset Dataset API 的更多信息。 \n",
    "* 训练次数：训练循环应该在数据传递的时期内迭代多少次。 \n",
    "* 在小批量梯度下降的每个时期内使用的批量大小：考虑为一个权重更新步骤计算梯度的训练示例的数量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "brilliant-federation",
   "metadata": {},
   "outputs": [],
   "source": [
    "history = model.fit(\n",
    "    # 输入示例，作为 NumPy 数组\n",
    "    inputs, \n",
    "    # 相应的训练目标，作为一个 NumPy 数组\n",
    "    targets, \n",
    "    # 训练循环将遍历数据 5 次。\n",
    "    epochs=5, \n",
    "    # 训练循环将分批迭代 128 个示例的数据。\n",
    "    batch_size=128 \n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "desirable-scholarship",
   "metadata": {},
   "source": [
    "调用返回一个 History 对象。 该对象包含一个历史字段，它是一个字典拟合，将键（例如“损失”或特定度量名称）映射到其每个时期值的列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sharing-intelligence",
   "metadata": {},
   "outputs": [],
   "source": [
    "history.history"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "social-console",
   "metadata": {},
   "source": [
    "### 监控验证数据的损失和指标"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "illegal-shareware",
   "metadata": {},
   "source": [
    "机器学习的目标不是获得在训练数据上表现良好的模型——这很容易，你所要做的就是跟随梯度。 目标是获得总体上表现良好的模型，特别是在模型以前从未遇到过的数据点上。 仅仅因为模型在其训练数据上表现良好并不意味着它在从未见过的数据上表现良好！ 例如，您的模型可能最终只会记住您的训练样本与其目标之间的映射，这对于为模型从未见过的数据预测目标的任务毫无用处。 我们将在第 5 章中更详细地讨论这一点。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tough-wichita",
   "metadata": {},
   "source": [
    "为了密切关注模型在新数据上的表现，标准做法是将训练数据的一个子集保留为“验证数据”：您不会在此数据上训练模型，但您将使用它来计算 损失值和指标值。 您可以通过在 fit() 中使用 validation_data 参数来完成此操作。 与训练数据一样，验证数据可以作为 NumPy 数组或作为 TensorFlow Dataset 对象传递。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "personal-belfast",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = keras.Sequential([keras.layers.Dense(1)])\n",
    "model.compile(optimizer=keras.optimizers.RMSprop(learning_rate=0.1),\n",
    "              loss=keras.losses.MeanSquaredError(),\n",
    "              metrics=[keras.metrics.BinaryAccuracy()])\n",
    "\n",
    "# 为了避免验证数据中只有一个类的样本，请使用随机索引排列对输入和目标进行混洗。\n",
    "indices_permutation = np.random.permutation(len(inputs)) \n",
    "shuffled_inputs = inputs[indices_permutation]\n",
    "shuffled_targets = targets[indices_permutation]\n",
    "\n",
    "# 为“验证”保留 30% 的训练输入和目标（我们将从训练中排除这些样本并保留它们以计算“验证损失”和指标）\n",
    "num_validation_samples = int(0.3 * len(inputs))\n",
    "val_inputs = shuffled_inputs[:num_validation_samples]\n",
    "val_targets = shuffled_targets[:num_validation_samples]\n",
    "training_inputs = shuffled_inputs[num_validation_samples:]\n",
    "training_targets = shuffled_targets[num_validation_samples:] \n",
    "\n",
    "model.fit(\n",
    "    # 训练数据，用于更新模型的权重\n",
    "    training_inputs,\n",
    "    training_targets, \n",
    "    epochs=5,\n",
    "    batch_size=16,\n",
    "    # 验证数据，仅用于监控“验证损失”和指标\n",
    "    validation_data=(val_inputs, val_targets)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blank-student",
   "metadata": {},
   "source": [
    "验证数据上的损失值称为“验证损失”，以区别于“训练损失”。 请注意，必须将训练数据和验证数据严格分开：验证的目的是监控模型学习的内容是否对新数据真正有用。 如果模型在训练期间看到任何验证数据，则您的验证损失和指标将存在缺陷。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blessed-rough",
   "metadata": {},
   "source": [
    "请注意，如果要在训练完成后计算验证损失和指标，可以调用方法：evaluate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "super-medicare",
   "metadata": {},
   "source": [
    "```python\n",
    "loss_and_metrics = model.evaluate(val_inputs, val_targets, batch_size=128)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "meaningful-imaging",
   "metadata": {},
   "source": [
    "evaluate(）将批量迭代（大小为batch_size）传递的数据，并返回标量列表，其中第一个条目是验证损失，后面的条目是验证指标。 如果模型没有指标，则只返回验证损失（而不是列表）。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "infrared-rebecca",
   "metadata": {},
   "source": [
    "### 推理：训练后使用模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pressed-clear",
   "metadata": {},
   "source": [
    "一旦你训练了你的模型，你就会想要用它来对新数据进行预测。 这称为“推理”。 要做到这一点，一个简单的方法就是调用模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "optional-pathology",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Takes a NumPy array or TensorFlow tensor and returns a TensorFlow tensor\n",
    "predictions = model(new_inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "massive-terminal",
   "metadata": {},
   "source": [
    "但是，这将一次处理 new_inputs 中的所有输入，如果您正在查看大量数据，这可能不可行（特别是，它可能需要比 GPU 多的内存）。\n",
    "\n",
    "进行推理的更好方法是使用predict()方法。 它将迭代小批量中的数据，并返回一个 NumPy 预测数组。 与 不同的是，它还可以处理调用 TensorFlow Dataset 对象。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unnecessary-string",
   "metadata": {},
   "source": [
    "例如，如果我们将一些验证数据与我们之前训练过的 predict() 线性模型一起使用，我们会得到与模型对每个输入样本的预测相对应的标量分数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "comparative-scanner",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = model.predict(val_inputs, batch_size=128)\n",
    "predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "distributed-workstation",
   "metadata": {},
   "source": [
    "现在，这就是您需要了解的有关 Keras 模型的全部信息。 此时，您已准备好在下一章继续使用 Keras 解决现实世界的机器问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unsigned-commitment",
   "metadata": {},
   "source": [
    "## 章节总结"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accurate-china",
   "metadata": {},
   "source": [
    "* TensorFlow 是一个行业强度的数值计算框架，可以在 CPU、GPU 或 TPU 上运行。 它可以自动计算任何可微表达式的梯度，可以分发到许多设备，并且可以将程序导出到各种外部运行时——甚至是 Javascript。\n",
    "* Keras 是使用 TensorFlow 进行深度学习的标准 API。 这就是我们将在本书中使用的内容。\n",
    "* 关键的 TensorFlow 对象包括张量、变量、张量运算和梯度带。\n",
    "* Keras 的核心类是 . 一层封装了一些权重和一些层计算。 层被组装成模型。\n",
    "* 在开始训练模型之前，您需要选择一个优化器、一个损失和一些指标，这些指标是您通过 model.compile() 方法指定的。\n",
    "* 要训练模型，您可以使用该方法，该方法为您运行小批量梯度下降 fit()。 您还可以使用它来监控“验证数据”的损失和指标，这是模型在训练期间看不到的一组输入。\n",
    "* 训练模型后，使用 model.predict() 方法生成对新输入的预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "swiss-crystal",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tensorflow]",
   "language": "python",
   "name": "conda-env-tensorflow-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
